/*******************************************************
 Demo Program for HIDAPI

 Alan Ott
 Signal 11 Software

 2010-07-20

 Copyright 2010, All Rights Reserved

 This contents of this file may be used by anyone
 for any reason without any conditions and may be
 used as a starting point for your own applications
 which use HIDAPI.
********************************************************/


#include <fx.h>

#include "hidapi.h"
#include "mac_support.h"
#include <string.h>
#include <stdlib.h>
#include <limits.h>

#ifdef _WIN32
// Thanks Microsoft, but I know how to use strncpy().
#pragma warning(disable:4996)
#endif

class MainWindow : public FXMainWindow {
    FXDECLARE(MainWindow)

public:
    enum {
        ID_FIRST = FXMainWindow::ID_LAST,
        ID_CONNECT,
        ID_DISCONNECT,
        ID_RESCAN,
        ID_SEND_OUTPUT_REPORT,
        ID_SEND_FEATURE_REPORT,
        ID_GET_FEATURE_REPORT,
        ID_CLEAR,
        ID_TIMER,
        ID_MAC_TIMER,
        ID_LAST,
    };

private:
    FXList *device_list;
    FXButton *connect_button;
    FXButton *disconnect_button;
    FXButton *rescan_button;
    FXButton *output_button;
    FXLabel *connected_label;
    FXTextField *output_text;
    FXTextField *output_len;
    FXButton *feature_button;
    FXButton *get_feature_button;
    FXTextField *feature_text;
    FXTextField *feature_len;
    FXTextField *get_feature_text;
    FXText *input_text;
    FXFont *title_font;

    struct hid_device_info *devices;
    hid_device *connected_device;
    size_t getDataFromTextField(FXTextField *tf, char *buf, size_t len);
    int getLengthFromTextField(FXTextField *tf);


protected:
    MainWindow() {};
public:
    MainWindow(FXApp *a);
    ~MainWindow();
    virtual void create();

    long onConnect(FXObject *sender, FXSelector sel, void *ptr);
    long onDisconnect(FXObject *sender, FXSelector sel, void *ptr);
    long onRescan(FXObject *sender, FXSelector sel, void *ptr);
    long onSendOutputReport(FXObject *sender, FXSelector sel, void *ptr);
    long onSendFeatureReport(FXObject *sender, FXSelector sel, void *ptr);
    long onGetFeatureReport(FXObject *sender, FXSelector sel, void *ptr);
    long onClear(FXObject *sender, FXSelector sel, void *ptr);
    long onTimeout(FXObject *sender, FXSelector sel, void *ptr);
    long onMacTimeout(FXObject *sender, FXSelector sel, void *ptr);
};

// FOX 1.7 changes the timeouts to all be nanoseconds.
// Fox 1.6 had all timeouts as milliseconds.
#if (FOX_MINOR >= 7)
const int timeout_scalar = 1000 * 1000;
#else
const int timeout_scalar = 1;
#endif

FXMainWindow *g_main_window;


FXDEFMAP(MainWindow) MainWindowMap [] = {
    FXMAPFUNC(SEL_COMMAND, MainWindow::ID_CONNECT, MainWindow::onConnect),
    FXMAPFUNC(SEL_COMMAND, MainWindow::ID_DISCONNECT, MainWindow::onDisconnect),
    FXMAPFUNC(SEL_COMMAND, MainWindow::ID_RESCAN, MainWindow::onRescan),
    FXMAPFUNC(SEL_COMMAND, MainWindow::ID_SEND_OUTPUT_REPORT, MainWindow::onSendOutputReport),
    FXMAPFUNC(SEL_COMMAND, MainWindow::ID_SEND_FEATURE_REPORT, MainWindow::onSendFeatureReport),
    FXMAPFUNC(SEL_COMMAND, MainWindow::ID_GET_FEATURE_REPORT, MainWindow::onGetFeatureReport),
    FXMAPFUNC(SEL_COMMAND, MainWindow::ID_CLEAR, MainWindow::onClear),
    FXMAPFUNC(SEL_TIMEOUT, MainWindow::ID_TIMER, MainWindow::onTimeout),
    FXMAPFUNC(SEL_TIMEOUT, MainWindow::ID_MAC_TIMER, MainWindow::onMacTimeout),
};

FXIMPLEMENT(MainWindow, FXMainWindow, MainWindowMap, ARRAYNUMBER(MainWindowMap));

MainWindow::MainWindow(FXApp *app)
    : FXMainWindow(app, "HIDAPI Test Application", NULL, NULL, DECOR_ALL, 200, 100, 425, 700)
{
    devices = NULL;
    connected_device = NULL;

    FXVerticalFrame *vf = new FXVerticalFrame(this, LAYOUT_FILL_Y | LAYOUT_FILL_X);

    FXLabel *label = new FXLabel(vf, "HIDAPI Test Tool");
    title_font = new FXFont(getApp(), "Arial", 14, FXFont::Bold);
    label->setFont(title_font);

    new FXLabel(vf,
                "Select a device and press Connect.", NULL, JUSTIFY_LEFT);
    new FXLabel(vf,
                "Output data bytes can be entered in the Output section, \n"
                "separated by space, comma or brackets. Data starting with 0x\n"
                "is treated as hex. Data beginning with a 0 is treated as \n"
                "octal. All other data is treated as decimal.", NULL, JUSTIFY_LEFT);
    new FXLabel(vf,
                "Data received from the device appears in the Input section.",
                NULL, JUSTIFY_LEFT);
    new FXLabel(vf,
                "Optionally, a report length may be specified. Extra bytes are\n"
                "padded with zeros. If no length is specified, the length is \n"
                "inferred from the data.",
                NULL, JUSTIFY_LEFT);
    new FXLabel(vf, "");

    // Device List and Connect/Disconnect buttons
    FXHorizontalFrame *hf = new FXHorizontalFrame(vf, LAYOUT_FILL_X);
    //device_list = new FXList(new FXHorizontalFrame(hf,FRAME_SUNKEN|FRAME_THICK, 0,0,0,0, 0,0,0,0), NULL, 0, LISTBOX_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT, 0,0,300,200);
    device_list = new FXList(new FXHorizontalFrame(hf, FRAME_SUNKEN | FRAME_THICK | LAYOUT_FILL_X | LAYOUT_FILL_Y, 0, 0, 0, 0, 0, 0, 0, 0), NULL, 0, LISTBOX_NORMAL | LAYOUT_FILL_X | LAYOUT_FILL_Y, 0, 0, 300, 200);
    FXVerticalFrame *buttonVF = new FXVerticalFrame(hf);
    connect_button = new FXButton(buttonVF, "Connect", NULL, this, ID_CONNECT, BUTTON_NORMAL | LAYOUT_FILL_X);
    disconnect_button = new FXButton(buttonVF, "Disconnect", NULL, this, ID_DISCONNECT, BUTTON_NORMAL | LAYOUT_FILL_X);
    disconnect_button->disable();
    rescan_button = new FXButton(buttonVF, "Re-Scan devices", NULL, this, ID_RESCAN, BUTTON_NORMAL | LAYOUT_FILL_X);
    new FXHorizontalFrame(buttonVF, 0, 0, 0, 0, 0, 0, 0, 50, 0);

    connected_label = new FXLabel(vf, "Disconnected");

    new FXHorizontalFrame(vf);

    // Output Group Box
    FXGroupBox *gb = new FXGroupBox(vf, "Output", FRAME_GROOVE | LAYOUT_FILL_X);
    FXMatrix *matrix = new FXMatrix(gb, 3, MATRIX_BY_COLUMNS | LAYOUT_FILL_X);
    new FXLabel(matrix, "Data");
    new FXLabel(matrix, "Length");
    new FXLabel(matrix, "");

    //hf = new FXHorizontalFrame(gb, LAYOUT_FILL_X);
    output_text = new FXTextField(matrix, 30, NULL, 0, TEXTFIELD_NORMAL | LAYOUT_FILL_X | LAYOUT_FILL_COLUMN);
    output_text->setText("1 0x81 0");
    output_len = new FXTextField(matrix, 5, NULL, 0, TEXTFIELD_NORMAL | LAYOUT_FILL_X | LAYOUT_FILL_COLUMN);
    output_button = new FXButton(matrix, "Send Output Report", NULL, this, ID_SEND_OUTPUT_REPORT, BUTTON_NORMAL | LAYOUT_FILL_X);
    output_button->disable();
    //new FXHorizontalFrame(matrix, LAYOUT_FILL_X);

    //hf = new FXHorizontalFrame(gb, LAYOUT_FILL_X);
    feature_text = new FXTextField(matrix, 30, NULL, 0, TEXTFIELD_NORMAL | LAYOUT_FILL_X | LAYOUT_FILL_COLUMN);
    feature_len = new FXTextField(matrix, 5, NULL, 0, TEXTFIELD_NORMAL | LAYOUT_FILL_X | LAYOUT_FILL_COLUMN);
    feature_button = new FXButton(matrix, "Send Feature Report", NULL, this, ID_SEND_FEATURE_REPORT, BUTTON_NORMAL | LAYOUT_FILL_X);
    feature_button->disable();

    get_feature_text = new FXTextField(matrix, 30, NULL, 0, TEXTFIELD_NORMAL | LAYOUT_FILL_X | LAYOUT_FILL_COLUMN);
    new FXWindow(matrix);
    get_feature_button = new FXButton(matrix, "Get Feature Report", NULL, this, ID_GET_FEATURE_REPORT, BUTTON_NORMAL | LAYOUT_FILL_X);
    get_feature_button->disable();


    // Input Group Box
    gb = new FXGroupBox(vf, "Input", FRAME_GROOVE | LAYOUT_FILL_X | LAYOUT_FILL_Y);
    FXVerticalFrame *innerVF = new FXVerticalFrame(gb, LAYOUT_FILL_X | LAYOUT_FILL_Y);
    input_text = new FXText(new FXHorizontalFrame(innerVF, LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_SUNKEN | FRAME_THICK, 0, 0, 0, 0, 0, 0, 0, 0), NULL, 0, LAYOUT_FILL_X | LAYOUT_FILL_Y);
    input_text->setEditable(false);
    new FXButton(innerVF, "Clear", NULL, this, ID_CLEAR, BUTTON_NORMAL | LAYOUT_RIGHT);


}

MainWindow::~MainWindow()
{
    if(connected_device) {
        hid_close(connected_device);
    }
    hid_exit();
    delete title_font;
}

void
MainWindow::create()
{
    FXMainWindow::create();
    show();

    onRescan(NULL, 0, NULL);


#ifdef __APPLE__
    init_apple_message_system();
#endif

    getApp()->addTimeout(this, ID_MAC_TIMER,
                         50 * timeout_scalar /*50ms*/);
}

long
MainWindow::onConnect(FXObject *sender, FXSelector sel, void *ptr)
{
    if(connected_device != NULL) {
        return 1;
    }

    FXint cur_item = device_list->getCurrentItem();
    if(cur_item < 0) {
        return -1;
    }
    FXListItem *item = device_list->getItem(cur_item);
    if(!item) {
        return -1;
    }
    struct hid_device_info *device_info = (struct hid_device_info *) item->getData();
    if(!device_info) {
        return -1;
    }

    connected_device =  hid_open_path(device_info->path);

    if(!connected_device) {
        FXMessageBox::error(this, MBOX_OK, "Device Error", "Unable To Connect to Device");
        return -1;
    }

    hid_set_nonblocking(connected_device, 1);

    getApp()->addTimeout(this, ID_TIMER,
                         5 * timeout_scalar /*5ms*/);

    FXString s;
    s.format("Connected to: %04hx:%04hx -", device_info->vendor_id, device_info->product_id);
    s += FXString(" ") + device_info->manufacturer_string;
    s += FXString(" ") + device_info->product_string;
    connected_label->setText(s);
    output_button->enable();
    feature_button->enable();
    get_feature_button->enable();
    connect_button->disable();
    disconnect_button->enable();
    input_text->setText("");


    return 1;
}

long
MainWindow::onDisconnect(FXObject *sender, FXSelector sel, void *ptr)
{
    hid_close(connected_device);
    connected_device = NULL;
    connected_label->setText("Disconnected");
    output_button->disable();
    feature_button->disable();
    get_feature_button->disable();
    connect_button->enable();
    disconnect_button->disable();

    getApp()->removeTimeout(this, ID_TIMER);

    return 1;
}

long
MainWindow::onRescan(FXObject *sender, FXSelector sel, void *ptr)
{
    struct hid_device_info *cur_dev;

    device_list->clearItems();

    // List the Devices
    hid_free_enumeration(devices);
    devices = hid_enumerate(0x0, 0x0);
    cur_dev = devices;
    while(cur_dev) {
        // Add it to the List Box.
        FXString s;
        FXString usage_str;
        s.format("%04hx:%04hx -", cur_dev->vendor_id, cur_dev->product_id);
        s += FXString(" ") + cur_dev->manufacturer_string;
        s += FXString(" ") + cur_dev->product_string;
        usage_str.format(" (usage: %04hx:%04hx) ", cur_dev->usage_page, cur_dev->usage);
        s += usage_str;
        FXListItem *li = new FXListItem(s, NULL, cur_dev);
        device_list->appendItem(li);

        cur_dev = cur_dev->next;
    }

    if(device_list->getNumItems() == 0) {
        device_list->appendItem("*** No Devices Connected ***");
    }
    else {
        device_list->selectItem(0);
    }

    return 1;
}

size_t
MainWindow::getDataFromTextField(FXTextField *tf, char *buf, size_t len)
{
    const char *delim = " ,{}\t\r\n";
    FXString data = tf->getText();
    const FXchar *d = data.text();
    size_t i = 0;

    // Copy the string from the GUI.
    size_t sz = strlen(d);
    char *str = (char *) malloc(sz + 1);
    strcpy(str, d);

    // For each token in the string, parse and store in buf[].
    char *token = strtok(str, delim);
    while(token) {
        char *endptr;
        long int val = strtol(token, &endptr, 0);
        buf[i++] = val;
        token = strtok(NULL, delim);
    }

    free(str);
    return i;
}

/* getLengthFromTextField()
   Returns length:
	 0: empty text field
	>0: valid length
	-1: invalid length */
int
MainWindow::getLengthFromTextField(FXTextField *tf)
{
    long int len;
    FXString str = tf->getText();
    size_t sz = str.length();

    if(sz > 0) {
        char *endptr;
        len = strtol(str.text(), &endptr, 0);
        if(endptr != str.text() && *endptr == '\0') {
            if(len <= 0) {
                FXMessageBox::error(this, MBOX_OK, "Invalid length", "Enter a length greater than zero.");
                return -1;
            }
            return len;
        }
        else {
            return -1;
        }
    }

    return 0;
}

long
MainWindow::onSendOutputReport(FXObject *sender, FXSelector sel, void *ptr)
{
    char buf[256];
    size_t data_len, len;
    int textfield_len;

    memset(buf, 0x0, sizeof(buf));
    textfield_len = getLengthFromTextField(output_len);
    data_len = getDataFromTextField(output_text, buf, sizeof(buf));

    if(textfield_len < 0) {
        FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is invalid. Please enter a number in hex, octal, or decimal.");
        return 1;
    }

    if(textfield_len > sizeof(buf)) {
        FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is too long.");
        return 1;
    }

    len = (textfield_len) ? textfield_len : data_len;

    int res = hid_write(connected_device, (const unsigned char *)buf, len);
    if(res < 0) {
        FXMessageBox::error(this, MBOX_OK, "Error Writing", "Could not write to device. Error reported was: %ls", hid_error(connected_device));
    }

    return 1;
}

long
MainWindow::onSendFeatureReport(FXObject *sender, FXSelector sel, void *ptr)
{
    char buf[256];
    size_t data_len, len;
    int textfield_len;

    memset(buf, 0x0, sizeof(buf));
    textfield_len = getLengthFromTextField(feature_len);
    data_len = getDataFromTextField(feature_text, buf, sizeof(buf));

    if(textfield_len < 0) {
        FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is invalid. Please enter a number in hex, octal, or decimal.");
        return 1;
    }

    if(textfield_len > sizeof(buf)) {
        FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is too long.");
        return 1;
    }

    len = (textfield_len) ? textfield_len : data_len;

    int res = hid_send_feature_report(connected_device, (const unsigned char *)buf, len);
    if(res < 0) {
        FXMessageBox::error(this, MBOX_OK, "Error Writing", "Could not send feature report to device. Error reported was: %ls", hid_error(connected_device));
    }

    return 1;
}

long
MainWindow::onGetFeatureReport(FXObject *sender, FXSelector sel, void *ptr)
{
    char buf[256];
    size_t len;

    memset(buf, 0x0, sizeof(buf));
    len = getDataFromTextField(get_feature_text, buf, sizeof(buf));

    if(len != 1) {
        FXMessageBox::error(this, MBOX_OK, "Too many numbers", "Enter only a single report number in the text field");
    }

    int res = hid_get_feature_report(connected_device, (unsigned char *)buf, sizeof(buf));
    if(res < 0) {
        FXMessageBox::error(this, MBOX_OK, "Error Getting Report", "Could not get feature report from device. Error reported was: %ls", hid_error(connected_device));
    }

    if(res > 0) {
        FXString s;
        s.format("Returned Feature Report. %d bytes:\n", res);
        for(int i = 0; i < res; i++) {
            FXString t;
            t.format("%02hhx ", buf[i]);
            s += t;
            if((i + 1) % 4 == 0) {
                s += " ";
            }
            if((i + 1) % 16 == 0) {
                s += "\n";
            }
        }
        s += "\n";
        input_text->appendText(s);
        input_text->setBottomLine(INT_MAX);
    }

    return 1;
}

long
MainWindow::onClear(FXObject *sender, FXSelector sel, void *ptr)
{
    input_text->setText("");
    return 1;
}

long
MainWindow::onTimeout(FXObject *sender, FXSelector sel, void *ptr)
{
    unsigned char buf[256];
    int res = hid_read(connected_device, buf, sizeof(buf));

    if(res > 0) {
        FXString s;
        s.format("Received %d bytes:\n", res);
        for(int i = 0; i < res; i++) {
            FXString t;
            t.format("%02hhx ", buf[i]);
            s += t;
            if((i + 1) % 4 == 0) {
                s += " ";
            }
            if((i + 1) % 16 == 0) {
                s += "\n";
            }
        }
        s += "\n";
        input_text->appendText(s);
        input_text->setBottomLine(INT_MAX);
    }
    if(res < 0) {
        input_text->appendText("hid_read() returned error\n");
        input_text->setBottomLine(INT_MAX);
    }

    getApp()->addTimeout(this, ID_TIMER,
                         5 * timeout_scalar /*5ms*/);
    return 1;
}

long
MainWindow::onMacTimeout(FXObject *sender, FXSelector sel, void *ptr)
{
#ifdef __APPLE__
    check_apple_events();

    getApp()->addTimeout(this, ID_MAC_TIMER,
                         50 * timeout_scalar /*50ms*/);
#endif

    return 1;
}

int main(int argc, char **argv)
{
    FXApp app("HIDAPI Test Application", "Signal 11 Software");
    app.init(argc, argv);
    g_main_window = new MainWindow(&app);
    app.create();
    app.run();
    return 0;
}
